\section{Conclusion}
The software development community is ready to try something different.  The
\textsl{waterfall software development model} has been used and is not flexible to
change. With change becoming more prevalent in today's
software development environment, the waterfall model will eventually fail. 
The agile software movement has shown it can flawlessly adapt to a
change within the development atmosphere.  Through agile practices such as
iterative development and continuous integration, software is developed with the
customer's needs in mind.  With the software available in a stable and
releasable state, the customer has the ability to provide feedback based on the
current software build.  

Agile software development has been shown to work in an object oriented
programming environment.  In order to adopt these same practices to a scripting
language such as Tcl, the practices must be completely understood and adapted
accordingly.  For instance, the agile refactoring practice can not be applied
directly to scripting languages.  Only a subset of the available refactorings
will work with a scripting language.  In addition, continuous integration must
be adjusted to work with an interpreted language rather than a compiled
language.  

One of the keys to agile providing a stable development environment is unit
testing. By writing unit tests before the source code, the developer can prevent
defects from appearing in their software.  Further, by running unit tests as
part of an automated build process within the continuous integration practice,
the developer can be confident that their software is behaving as they would
expect.  Scripting
languages can be unit tested just like any other programming language.  If a
unit test framework is not available, creating one is not as hard as it would
seem.  
The ``t-unit'' framework was created to fit the unit testing
needs of Tcl programmers.  ``t-unit'' was modeled after the Java unit test framework,
JUnit.  As a result, many developers will be familiar with assert calls used
throughout the ``t-unit'' framework.  

In order to be even more like JUnit, the ``t-unit'' package was incorporated
into a plug-in for the Eclipse open development platform.  The plug-in,
TUnit, offers Tcl programmers an environment to create, edit and unit test
Tcl projects from a central location within Eclipse.  TUnit was also
extended to work with a competing Eclipse plug-in known as the Dynamic Languages
Toolkit (DLTK).  The DLTK plug-in does not offer unit testing to its users. 
With the TUnit extension, users of DLTK can use the ``t-unit'' package to
unit test their projects with a specially designed graphical user interface
(GUI) to display the results.  Lastly, ``t-unit,'' TUnit and the TUnit
extension have been released as open source projects, in line with the goals of 
the NSF Recourse project and facilitating immediate 
availability to the software development community at large.
